package com.ruoyi.mes.service.impl;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import com.ruoyi.mes.domain.Device;
import com.ruoyi.mes.domain.ProceInfo;
import com.ruoyi.mes.mapper.DeviceMapper;
import com.ruoyi.mes.mapper.ProceInfoMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.mes.mapper.DeviceParameterMapper;
import com.ruoyi.mes.domain.DeviceParameter;
import com.ruoyi.mes.service.IDeviceParameterService;

/**
 * 设备参数Service业务层处理
 * 
 * @author LongAndHao
 * @date 2024-11-04
 */
@Service
public class DeviceParameterServiceImpl implements IDeviceParameterService 
{
    @Autowired
    private DeviceParameterMapper deviceParameterMapper;
    @Autowired
    private DeviceMapper deviceMapper;
    @Autowired
    private ProceInfoMapper proceInfoMapper;
    /**
     * 查询设备参数
     * 
     * @param id 设备参数主键
     * @return 设备参数
     */
    @Override
    public DeviceParameter selectDeviceParameterById(Long id)
    {
        DeviceParameter deviceParameter = deviceParameterMapper.selectDeviceParameterById(id);
        Device device = deviceMapper.selectDeviceById(deviceParameter.getDeviceId());

        deviceParameter.setDeviceName(device.getDeviceName());

        return deviceParameter;
    }

    /**
     * 查询设备参数列表
     *
     * @param deviceParameter 设备参数
     * @return 设备参数
     */
    @Override
    public List<DeviceParameter> selectDeviceParameterList(DeviceParameter deviceParameter)
    {
       List<DeviceParameter> deviceParameters = deviceParameterMapper.selectDeviceParameterList(deviceParameter);
       for (DeviceParameter deviceParameter1 : deviceParameters){
           Device device = deviceMapper.selectDeviceById(deviceParameter1.getDeviceId());
           deviceParameter1.setDeviceName(device.getDeviceName());
       }

        return deviceParameters;
    }

    /**
     * 新增设备参数
     * 
     * @param deviceParameter 设备参数
     * @return 结果
     */
    @Override
    public int insertDeviceParameter(DeviceParameter deviceParameter)
    {
        return deviceParameterMapper.insertDeviceParameter(deviceParameter);
    }

    /**
     * 修改设备参数
     *
     * @param deviceParameter 设备参数
     * @return 结果
     */
    @Override
    public int updateDeviceParameter(DeviceParameter deviceParameter) {
        // 获取设备参数
        DeviceParameter deviceParameter1 = deviceParameterMapper.selectDeviceParameterById(deviceParameter.getId());

        // 获取参数值和影响百分比
        Long num1 = Long.valueOf(deviceParameter1.getParameterValue());
        Long percentage = Long.valueOf(deviceParameter.getImpactPercentage());
        Long num = Long.valueOf(deviceParameter.getParameterValue());

        // 计算两个参数值的绝对差并乘以百分比
        Long difference = Math.abs(num - num1);
        Long num2 = difference * percentage / 100;

        // 获取设备ID并查询该设备下所有参数（排除“节拍”参数）
        Long deviceId = deviceParameter.getDeviceId();
        List<DeviceParameter> deviceParameterList = deviceParameterMapper.selectDeviceParameterByDeviceIdNoJiePai(deviceId);

        // 计算新的节拍值（提取到循环外，避免重复计算）
        double newValue = 0;

// 遍历设备参数，进行相应更新
        for (DeviceParameter deviceParameter3 : deviceParameterList) {
            if ("节拍".equals(deviceParameter3.getParameterName())) {
                Long jiepai = Long.valueOf(deviceParameter3.getParameterValue());

                // 计算新的节拍值，根据新旧值的对比来选择加减百分比差值
                if (num > num1) {
                    // 百分比差值减少，保留一位小数
                    newValue = Math.round(jiepai * (1 - (num2 / 100.0)) * 10) / 10.0;
                } else if (num < num1) {
                    // 百分比差值增加，保留一位小数
                    newValue = Math.round(jiepai * (1 + (num2 / 100.0)) * 10) / 10.0;
                }


                if (newValue != 0) {
                    // 四舍五入后的新值
                    Long newValue1 = Math.round(newValue);
                    // 只有当节拍值发生变化时才进行更新
                    if (!newValue1.toString().equals(deviceParameter3.getParameterValue())) {
                        deviceParameter3.setParameterValue(newValue1);
                        deviceParameterMapper.updateDeviceParameter(deviceParameter3);
                        Long id = deviceParameter3.getId();
                        List<ProceInfo> proceInfos = proceInfoMapper.selectProceInfoByParameterId(id);
                        for (ProceInfo proceInfo : proceInfos){
                            proceInfo.setTimes(newValue1);
                            proceInfoMapper.updateProceInfo(proceInfo);
                        }

                    }
                }
            }
        }

        // 更新设备参数本身
        return deviceParameterMapper.updateDeviceParameter(deviceParameter);
    }

    /**
     * 批量删除设备参数
     * 
     * @param ids 需要删除的设备参数主键
     * @return 结果
     */
    @Override
    public int deleteDeviceParameterByIds(Long[] ids)
    {
        return deviceParameterMapper.deleteDeviceParameterByIds(ids);
    }

    /**
     * 删除设备参数信息
     * 
     * @param id 设备参数主键
     * @return 结果
     */
    @Override
    public int deleteDeviceParameterById(Long id)
    {
        return deviceParameterMapper.deleteDeviceParameterById(id);
    }
}
